package com.xyx.www;

import java.util.HashSet;
import java.util.Iterator;
import java.util.LinkedHashSet;
import java.util.Set;
import java.util.TreeSet;

class Person implements Comparable {

	private String stuName;
	private int stuAge;
	private int stuId;

	public Person() {
		super();
	}

	// 重写有参构造方法
	public Person(String stuName, int stuAge, int stuId) {
		super();
		this.stuName = stuName;
		this.stuAge = stuAge;
		this.stuId = stuId;
	}
	public void doStuding() {
		System.out.println(this.stuName+"正在学习 ");
	}
	public void doSleepping() {
		System.out.println(this.stuAge+"岁的"+this.stuName+"正在上课睡觉");
	}

	public String getStuName() {
		return stuName;
	}

	public void setStuName(String stuName) {
		this.stuName = stuName;
	}

	public int getStuAge() {
		return stuAge;
	}

	public void setStuAge(int stuAge) {
		this.stuAge = stuAge;
	}

	public int getStuId() {
		return stuId;
	}

	public void setStuId(int stuId) {
		this.stuId = stuId;
	}

	@Override
	public String toString() {
		return "Person [stuName=" + stuName + ", stuAge=" + stuAge + ", stuId=" + stuId + "]";
	}

	@Override
	// 重写equals方法判断Person的对象属性值是否相等
	//自定义排序规则
	public boolean equals(Object obj) {
		if (!(obj instanceof Person)) {
			return false;
		}
		Person per = (Person) obj;
		if (this.stuName != null && per.stuName != null && this.stuName.equals(per.stuName) && this.stuAge == per.stuAge
				&& this.stuId == per.stuId) {
			return true;

		} else {

			return false;
		}
	}

	@Override
	// 重写hashcode方法，使值确定为一个hashcode码确保地址一样
	public int hashCode() {
		// TODO Auto-generated method stub
		return 1;
	}

	/*
	 * (non-Javadoc)
	 * 
	 * @see java.lang.Comparable#compareTo(java.lang.Object)
	 * 重写排序方法比较学生年级的排序方法，需要实现Comparable接口，并重写compare方法
	 */
	@Override
	
	public int compareTo(Object o) {
		// TODO Auto-generated method stub
		//设置默认返回值为-1，优先将后进对象放在前面；
		Person per =(Person)o;
		int res_v=-1;
		if(per!=null) {
			/*this.表示后进来的对象调用compareTo方法进行比较，传参数Object
			 * Object表示前一个对象
			*/
			
			/*新添加进来对象的年龄和之前添加进来的对象的年龄进行比较
			新进来的值大于先前进来的值,返回大于0的正整数，将新进来的对象向后挪动*/
			
	       /*或者将表达式写成res_v=this.stuAge-per.getStuAge()
			相减大于零，则大于先前的对象的值，往后挪动
			相减小于零，则小于先前的对象的值，往前挪动*/
			if(this.stuAge>per.getStuAge()) {
				res_v=1;
				//新进来的值小于先前进来的值,返回小于0的正整数，将新进来的对象向前挪动
			}else if(this.stuAge<per.getStuAge()) {
				res_v= -1;
			}else if(this.stuAge==per.getStuAge()){
				res_v= 0;
			}
		}
	  return res_v;
	}


}

///////////////////////////////////////////////////////////////////////////
public class Test0801 {

	public static void main(String[] args) {
		// 无序
		// normSearch(10);
		// 二分法
		// dichotomy(101);
		//hashSet();
		// linkedHashSet();
		 treeSet();
	}

	/**
	 * @param s
	 *            二分法查找
	 */
	public static void dichotomy(int s) {
		// 定义数组
		int[] arr = new int[] { 2, 5, 9, 12, 15, 49, 56, 99, 100, 203 };
		// 定义最低位置初始为0；最高位置为数组最高位置的下标
		int low = 0, high = arr.length - 1, mid;
		// 当最低位置小于最高位置则进入循环
		while (low <= high) {
			// 中间位置为数组中间位置，则每次判断的最低与最高的一半
			mid = (low + high) / 2;
			// 匹配到输出
			if (arr[mid] == s) {
				System.out.println("在第" + (mid + 1) + "位置");
				break;
			}
			// 中间值小于s，最低值为mid+1，寻找间断移动至后半段
			else if (arr[mid] < s) {

				low = mid + 1;

			}
			// 中间值大于s，最高值为mid-1，寻找间断移动至前半段
			else {
				high = mid - 1;
			}

		}
		// 匹配不到响应值返回语句
		System.out.println("不存在！");

	}

	/**
	 * @param s
	 *            无序查找
	 */
	public static void normSearch(int s) {
		// 定义数组
		int[] arr = new int[] { 1, 2, 3, 4, 5, 6, 7, 8, 9 };
		// 数组遍历
		for (int i = 0; i < arr.length; i++) {
			// 匹配到一样的值中断循环直接输出数组位置
			if (arr[i] == s) {
				System.out.println(i + 1);
				break;
			}
			// 匹配到数组尽头则匹配失败
			if (i == arr.length - 1) {
				System.out.println("erro");
			}
		}
	}

	/**
	 * HashSet用法 允许有空值但只能有一个
	 */
	public static void hashSet() {

		// 创建set集合对象，父类指向子类
		Set<String> set0 = new HashSet<String>();
		set0.add("guojunchi"); // 不能重复，第二个会覆盖第一个 set0.add("guojunchi");
		set0.add("ganchuanhua");
		set0.add("zhengming");
		set0.add("wangfei");
		set0.add(null);
		set0.add(null);
		set0.add("hezhanqiang");
		// 排序能为null值，且只能为一个null值， set0.add(null);

		// 使用默认的toString方法输出
		System.out.println("使用默认的toString方法输出");
		System.out.println(set0);
		System.out.println("HashSet散列存储，无序存取");
		// 遍历循环，使用foreach循环，无下标
		for (String object : set0) {
			System.out.println(object);
		}
		System.out.println("Iterator迭代器遍历");
		// 获取集合的迭代器对象
		Iterator<String> it = set0.iterator();
		// it.hasNext() 判定有没有下一个元素，注意：开始位置是在第一个元素之前；
		while (it.hasNext()) {
			String obj = it.next();
			System.out.println(obj);
		}
		System.out.println("=================");
		if (set0.contains("guojunchi")) {
			System.out.println("包含guojunchi");
		} else {
			System.out.println("不包含guojunchi");
		}

		/*
		 * 测试对象是否重复，以及判断对象重复的方法 判断两个对象是否相等，必须要重写equals以及hashcode方法
		 * 这两个方法都符合相等条件才认为是两个相等的对象
		 * 
		 */
		/*
		 * Set<Person> set1 = new HashSet<Person>(); set1.add(new Person("小明", 25, 24));
		 * set1.add(new Person("小郭", 23, 24)); set1.add(new Person("小明", 25, 24));
		 * System.out.println(set1);
		 */

	}

	/**
	 * LinkedHashSet用法
	 */
	public static void linkedHashSet() {
		// 创建set集合对象，父类指向子类
		Set<String> set0 = new LinkedHashSet<String>();
		set0.add("guojunchi");
		// 不能重复，第二个会覆盖第一个
		set0.add("guojunchi");
		set0.add("ganchuanhua");
		set0.add("zhengming");
		set0.add("wangfei");
		set0.add("hezhanqiang");
		// 无排序能为null值
		set0.add(null);
		// 遍历循环，使用foreach循环，无下标，不排序，有序输出
		System.out.println("linkedHashSet,有序存储");
		for (String object : set0) {
			System.out.println(object);
		}
		System.out.println("Iterator迭代器遍历");
		// 获取集合的迭代器对象
		Iterator<String> it = set0.iterator();
		// it.hasNext() 判定有没有下一个元素，注意：开始位置是在第一个元素之前；
		while (it.hasNext()) {
			String obj = it.next();
			System.out.println(obj);
		}
		System.out.println("=================");
		if (set0.contains("guojunchi")) {
			System.out.println("包含guojunchi");
		} else {
			System.out.println("不包含guojunchi");
		}
	}

	/**
	 *
	 * TreeSet用法
	 */
	public static void treeSet() {
		/*// 创建set集合对象，父类指向子类
		Set<String> set0 = new TreeSet<String>();
		set0.add("guojunchi");
		// 不能重复，第二个会覆盖第一个
		set0.add("guojunchi");
		set0.add("ganchuanhua");
		set0.add("zhengming");
		set0.add("wangfei");
		set0.add("hezhanqiang");
		// 排序不能为null值
		// set0.add(null);
		// 遍历循环，使用foreach循环，无下标，排序存取
		System.out.println("treeSet,排序存取");
		for (String object : set0) {
			System.out.println(object);
		}
		System.out.println("Iterator迭代器遍历");
		// 获取集合的迭代器对象
		Iterator<String> it = set0.iterator();
		// it.hasNext() 判定有没有下一个元素，注意：开始位置是在第一个元素之前；
		while (it.hasNext()) {
			String obj = it.next();
			System.out.println(obj);
		}
		System.out.println("=================");
		if (set0.contains("guojunchi")) {
			System.out.println("包含guojunchi");
		} else {
			System.out.println("不包含guojunchi");
		}*/
		//创建tree集合器
		Set<Person> tree=new TreeSet<Person>();
		//添加Person对象到集合tree中
		tree.add(new Person("gjc",99,10));
		tree.add(new Person("gch",85,10));
		tree.add(new Person("hzq",65,10));
		//创建迭代器，循环输出排序后的结果，按年龄从小到大的顺序排序
		Iterator<Person> itPer=tree.iterator();
		while(itPer.hasNext()) {
			Person per1=itPer.next();
			System.out.println(per1);
		}
		
		
		
		
		
		
	}

}
